Technical learning notes, conference insights, and development guides

Author

Dario Airoldi

Published

August 8, 2025

Keywords

learning, development, azure, dotnet, conference, documentation

Elevating Development with .NET Aspire: AI, Cloud, and Beyond

Session Overview

Session Code: BRK106
Date: Microsoft Build 2025 (May 19-22, 2025)
Speakers:

Damian Edwards (Microsoft)
David Fowler (Microsoft)
Maddy Montaquila (PM, Aspire Team)
Devis Lucato (Office of the CTO)

This session presented the evolution and advancement of .NET Aspire over the past year, focusing on its role in modern development workflows, AI integration, cloud deployment strategies, and developer productivity enhancements.

Executive Summary

.NET Aspire has transformed from a local development orchestration tool to a comprehensive platform for building, testing, and deploying modern applications.

The session highlighted significant progress in AI integration, multi-language support, deployment flexibility, and developer experience improvements.
With over 60,000 developers and 70% adoption among top .NET customers at Microsoft, Aspire has proven its value as a cornerstone of modern .NET development.

Key Concepts and Analysis

1. Developer Experience Revolution

Core Problem Addressed: Modern application development has become increasingly complex, with developers managing multiple services, databases, authentication systems, and deployment targets.
The traditional onboarding process can take 2-3 weeks before developers can contribute meaningfully to a codebase.

Aspire’s Solution: - Unified Development Environment: Single point of orchestration for all application components - F5 Experience: Clone repository, hit F5, and start developing immediately - Integrated Observability: OpenTelemetry, logging, and resiliency built-in by default - Standardized Patterns: Consistent approach to configuration, dependency injection, and service discovery

Real-World Impact: The session mentioned a customer achieving same-day productivity - developers could clone a repository and start contributing by lunch on their first day.

2. AI Integration and Multi-Language Support

Devis Lucato’s Journey: Devis presented a compelling case study of migrating from Semantic Kernel to a more maintainable, Aspire-based architecture:

Original Challenge:

Maintaining identical SDKs in .NET, Python, Java, and TypeScript
Complex configuration files mixing business logic with infrastructure
Manual resource management and orchestration

Aspire-Enabled Solution:

Microservices Architecture: Each AI component as a separate service
Multi-Language Support: Python (LangChain, LlamaIndex), Node.js, and .NET components
Unified Configuration: Single app host managing all dependencies
Container-First Approach: Docker containers for each service with automatic orchestration

Technical Implementation:

// Example of multi-language service orchestration
var builder = DistributedApplication.CreateBuilder(args);

var postgres = builder.AddPostgres("postgres");
var redis = builder.AddRedis("redis");
var ollama = builder.AddOllama("ollama");

// .NET service
builder.AddProject<Projects.WebApp>("webapp")
    .WithReference(postgres)
    .WithReference(redis);

// Python service in container
builder.AddContainer("python-service", "myapp/python-processor")
    .WithReference(postgres)
    .WithReference(ollama);

// Node.js service
builder.AddNpmApp("frontend", "../frontend")
    .WithReference("webapp");

3. Deployment Strategy Evolution

From Single-Target to Multi-Environment: The session demonstrated Aspire’s evolution from supporting only Azure Container Apps to a flexible, multi-target deployment system.

Key Innovations:

Compute Environments

A new abstraction layer that separates application intent from deployment mechanics:

// Single environment (traditional)
builder.AddAzureContainerAppEnvironment("myenv");

// Multi-environment (new capability)
var frontendEnv = builder.AddAzureAppServiceEnvironment("frontend");
var backendEnv = builder.AddAzureContainerAppEnvironment("backend");

builder.AddProject<Projects.WebApp>("webapp")
    .WithEnvironment(frontendEnv);

builder.AddProject<Projects.ImageProcessor>("processor")
    .WithEnvironment(backendEnv);

Intent vs. Mechanics

Intent: Application structure, dependencies, and communication patterns
Mechanics: Where and how applications are deployed
Benefit: Same application definition can target multiple deployment environments

4. Command Line Interface (CLI) Introduction

New Capability: Aspire CLI provides command-line access to Aspire functionality, expanding beyond Visual Studio dependency:

# Template management
dotnet new update
dotnet new aspire

# Project operations
aspire new
aspire run
aspire add
aspire publish  # New deployment verb

Strategic Importance: - Enables CI/CD integration - Supports developers who prefer command-line workflows - Facilitates automation and scripting scenarios

5. Version Management and Maintenance

Current State: - Release cycle: Every 6 weeks - Latest version: 9.3 (as of session date) - Distribution: NuGet packages (no longer workload-based)

Update Process: 1. Template Updates: dotnet new update 2. Package Updates: Standard NuGet update procedures 3. SDK Updates: Manual project file editing required

Challenge Highlighted: Many developers are not updating to latest versions, missing bug fixes and new features.

6. Observability and Debugging

Built-in Capabilities: - Distributed Tracing: End-to-end request flow visualization - Centralized Logging: Unified log viewing across all services - Performance Monitoring: Real-time metrics and diagnostics - Console Integration: Direct access to service console logs

Developer Experience Enhancement: Instead of managing multiple terminal windows for different services, developers can view all logs and metrics from a single dashboard interface.

7. Community and Open Source

Growth Metrics: - 60,000+ developers using Aspire - 700+ community PRs (approximately 2 per day) - 70% adoption rate among top .NET customers at Microsoft

Open Source First Approach: - All development happens in the open - Community contributions actively encouraged - Transparent roadmap and feature development

Technical Deep Dive

Architecture Patterns

App Host Pattern

The App Host serves as the central configuration point for the entire application:

var builder = DistributedApplication.CreateBuilder(args);

// Infrastructure dependencies
var postgres = builder.AddPostgres("postgres");
var redis = builder.AddRedis("redis");
var storage = builder.AddAzureStorage("storage");

// Application services
var api = builder.AddProject<Projects.Api>("api")
    .WithReference(postgres)
    .WithReference(redis);

var web = builder.AddProject<Projects.Web>("web")
    .WithReference(api)
    .WithReference(storage);

builder.Build().Run();

Service Defaults

Standardized configuration applied to all services: - OpenTelemetry integration - Health checks - Resilience patterns (Polly) - Service discovery - Configuration management

Configuration Management

Traditional Approach Problems: - Mixed business and infrastructure configuration - Hard-coded API keys and connection strings - Environment-specific configuration files - Manual resource coordination

Aspire Solution: - Parameterized Configuration: External parameters for sensitive data - Connection String Injection: Automatic connection string management - Managed Identity Support: Seamless authentication token handling - Environment-Specific Overrides: Different configurations per deployment target

Deployment Flexibility

Multi-Target Support

// Azure Container Apps
builder.AddAzureContainerAppEnvironment("production");

// Azure App Service
builder.AddAzureAppServiceEnvironment("staging");

// Docker Compose (Preview)
builder.AddDockerComposeEnvironment("development");

// Kubernetes (Community)
builder.AddKubernetesEnvironment("cluster");

Cross-Environment Communication

Aspire automatically handles service-to-service communication across different compute environments: - Network configuration - Service discovery - Load balancing - Security policies

Best Practices and Recommendations

1. Starting New Projects

Recommendation: Begin with Aspire from day one rather than retrofitting existing applications.

Benefits: - Immediate productivity gains - Consistent development patterns - Built-in observability and resilience - Simplified deployment pipeline

2. Migration Strategy

For existing applications, focus on: 1. Authentication Patterns: Move from API keys to managed identities 2. Configuration Management: Externalize configuration from code 3. Service Boundaries: Identify natural service boundaries for containerization 4. Dependency Management: Catalog external dependencies (databases, message queues, etc.)

3. Multi-Language Integration

When incorporating non-.NET components: - Use container-based integration - Maintain consistent configuration patterns - Leverage Aspire’s orchestration capabilities - Document service contracts and APIs

4. Version Management

Update Aspire regularly (every 6 weeks)
Use dotnet new update for template updates
Implement automated dependency updates in CI/CD
Monitor for breaking changes in preview features

Future Roadmap and Implications

Near-Term Developments

Enhanced Multi-Language Support: Continued improvement of JavaScript, Python, and Go integration
Deployment Target Expansion: Additional cloud providers and deployment platforms
Visual Studio Integration: Improved template update experience
CLI Enhancements: Extended command-line functionality

Strategic Direction

Cloud-Agnostic Deployment: Support for AWS, Google Cloud, and other platforms
Enterprise Integration: Advanced CI/CD pipeline integration
AI/ML Workflow Support: Enhanced patterns for AI/ML application development
Performance Optimization: Continued focus on development and runtime performance

Challenges and Considerations

Current Limitations

Preview Features: Many advanced features still in preview
Learning Curve: Developers need to understand new patterns and concepts
Enterprise Integration: Some enterprise scenarios require custom solutions
Multi-Cloud Complexity: Cross-cloud deployments add complexity

Mitigation Strategies

Gradual Adoption: Start with local development, expand to deployment
Team Training: Invest in developer education and training
Community Engagement: Participate in open source community
Feedback Loop: Actively provide feedback to Microsoft team

Conclusion

.NET Aspire represents a significant evolution in .NET development tooling, addressing the complexity of modern application development through unified orchestration, simplified deployment, and enhanced developer experience. The session demonstrated maturity in AI integration, multi-language support, and deployment flexibility while maintaining the core promise of reducing developer friction.

The combination of strong community adoption, active open source development, and Microsoft’s internal usage validates Aspire’s approach to modern application development. As the platform continues to evolve, it positions itself as an essential tool for teams building cloud-native applications with .NET.

The key takeaway is that Aspire is not just a development tool but a comprehensive platform that bridges the gap between local development and production deployment, making it possible for developers to focus on business logic rather than infrastructure complexity.

References

.NET Aspire Documentation - Official Microsoft documentation for .NET Aspire, providing comprehensive guides, tutorials, and API references. Essential for understanding core concepts, getting started guides, and implementation details discussed in the session.
Semantic Kernel GitHub Repository - Open-source project mentioned by Devis Lucato as the foundation for his AI work. Demonstrates the evolution from multi-language SDK maintenance to web service-based architecture that Aspire enables.
Azure Container Apps Documentation - Primary deployment target for Aspire applications, featured prominently in the session’s deployment demonstrations. Understanding Container Apps is crucial for implementing the deployment strategies discussed.
Azure App Service Documentation - Alternative deployment target showcased in the multi-environment deployment demo. Represents the flexibility of Aspire’s compute environment abstraction.
OpenTelemetry .NET Documentation - Fundamental observability framework integrated into Aspire by default. Critical for understanding the telemetry and monitoring capabilities demonstrated in the session.
Azure Developer CLI (azd) Documentation - Deployment tool that integrates with Aspire for Azure deployments. Essential for understanding the deployment pipeline and infrastructure-as-code generation shown in the demos.
Docker Compose Documentation - Alternative orchestration approach mentioned in Devis’s presentation. Provides context for understanding why Aspire’s approach is superior for complex multi-service applications.
Microsoft Extensions AI Documentation - AI integration framework demonstrated in the session’s image processing demo. Shows how Aspire facilitates AI-powered application development.
Polly Resilience Framework - Resilience patterns and retry mechanisms built into Aspire’s service defaults. Important for understanding the built-in reliability features mentioned in the session.
.NET Generic Host Documentation - Foundation for Aspire’s app host pattern. Understanding the generic host model is crucial for comprehending how Aspire orchestrates application services.
Azure Resource Manager (ARM) Templates - Infrastructure-as-code output generated by Aspire deployments. Understanding ARM/Bicep is helpful for customizing and troubleshooting deployment outputs.
Container Registry Documentation - Container image management for Aspire applications using containerized services. Important for understanding the container deployment pipeline.
GitHub Actions for .NET - CI/CD integration mentioned as part of Aspire’s development workflow. Essential for implementing automated deployment pipelines.
Visual Studio Code C# Dev Kit - Development environment showcased in the session, including new launch project selection features. Important for developers using VS Code with Aspire.
Microsoft Learn - Cloud-Native Application Development - Educational content related to cloud-native development patterns that Aspire facilitates. Provides broader context for understanding modern application architecture principles discussed in the session.

# Elevating Development with .NET Aspire: AI, Cloud, and Beyond ## Session Overview **Session Code:** BRK106 **Date:** Microsoft Build 2025 (May 19-22, 2025) **Speakers:** - Damian Edwards (Microsoft) - David Fowler (Microsoft) - Maddy Montaquila (PM, Aspire Team) - Devis Lucato (Office of the CTO) This session presented the **evolution and advancement of .NET Aspire** over the past year, focusing on its role in modern **development workflows**, **AI integration**, **cloud deployment** strategies, and **developer productivity** enhancements. ## Executive Summary .NET Aspire has transformed from a **local development orchestration tool** to a **comprehensive platform for building, testing, and deploying modern applications**.<br> The session highlighted significant progress in **AI integration**, **multi-language support**, **deployment flexibility**, and developer experience improvements.<br> With over **60,000 developers** and **70% adoption** among top .NET customers at Microsoft, Aspire has proven its value as a cornerstone of modern .NET development. ## Key Concepts and Analysis ### 1. Developer Experience Revolution **Core Problem Addressed:** Modern application development has become increasingly complex, with developers managing multiple services, databases, authentication systems, and deployment targets.<br> The traditional onboarding process can take 2-3 weeks before developers can contribute meaningfully to a codebase. **Aspire's Solution:** - **Unified Development Environment:** **Single point of orchestration** for all application components - **F5 Experience:** **Clone repository, hit F5, and start developing immediately** - **Integrated Observability:** **OpenTelemetry, logging**, and resiliency built-in by default - **Standardized Patterns:** Consistent approach to configuration, dependency injection, and service discovery **Real-World Impact:** The session mentioned a customer achieving same-day productivity - developers could clone a repository and start contributing by lunch on their first day. ### 2. AI Integration and Multi-Language Support **Devis Lucato's Journey:** Devis presented a compelling case study of migrating from **Semantic Kernel** to a more maintainable, **Aspire-based architecture**: **Original Challenge:** - Maintaining identical **SDKs in .NET, Python, Java, and TypeScript** - Complex configuration files mixing business logic with infrastructure - Manual resource management and orchestration **Aspire-Enabled Solution:** - **Microservices Architecture:** Each AI component as a separate service - **Multi-Language Support:** Python (LangChain, LlamaIndex), Node.js, and .NET components - **Unified Configuration:** Single app host managing all dependencies - **Container-First Approach:** Docker containers for each service with automatic orchestration **Technical Implementation:** ```csharp // Example of multi-language service orchestration var builder = DistributedApplication.CreateBuilder(args); var postgres = builder.AddPostgres("postgres"); var redis = builder.AddRedis("redis"); var ollama = builder.AddOllama("ollama"); // .NET service builder.AddProject<Projects.WebApp>("webapp") .WithReference(postgres) .WithReference(redis); // Python service in container builder.AddContainer("python-service", "myapp/python-processor") .WithReference(postgres) .WithReference(ollama); // Node.js service builder.AddNpmApp("frontend", "../frontend") .WithReference("webapp"); ``` ### 3. Deployment Strategy Evolution **From Single-Target to Multi-Environment:** The session demonstrated Aspire's evolution from supporting only Azure Container Apps to a flexible, multi-target deployment system. **Key Innovations:** #### Compute Environments A new abstraction layer that separates application intent from deployment mechanics: ```csharp // Single environment (traditional) builder.AddAzureContainerAppEnvironment("myenv"); // Multi-environment (new capability) var frontendEnv = builder.AddAzureAppServiceEnvironment("frontend"); var backendEnv = builder.AddAzureContainerAppEnvironment("backend"); builder.AddProject<Projects.WebApp>("webapp") .WithEnvironment(frontendEnv); builder.AddProject<Projects.ImageProcessor>("processor") .WithEnvironment(backendEnv); ``` #### Intent vs. Mechanics - **Intent:** Application structure, dependencies, and communication patterns - **Mechanics:** Where and how applications are deployed - **Benefit:** Same application definition can target multiple deployment environments ### 4. Command Line Interface (CLI) Introduction **New Capability:** Aspire CLI provides command-line access to Aspire functionality, expanding beyond Visual Studio dependency: ```bash # Template management dotnet new update dotnet new aspire # Project operations aspire new aspire run aspire add aspire publish # New deployment verb ``` **Strategic Importance:** - Enables CI/CD integration - Supports developers who prefer command-line workflows - Facilitates automation and scripting scenarios ### 5. Version Management and Maintenance **Current State:** - Release cycle: Every 6 weeks - Latest version: 9.3 (as of session date) - Distribution: NuGet packages (no longer workload-based) **Update Process:** 1. **Template Updates:** `dotnet new update` 2. **Package Updates:** Standard NuGet update procedures 3. **SDK Updates:** Manual project file editing required **Challenge Highlighted:** Many developers are not updating to latest versions, missing bug fixes and new features. ### 6. Observability and Debugging **Built-in Capabilities:** - **Distributed Tracing:** End-to-end request flow visualization - **Centralized Logging:** Unified log viewing across all services - **Performance Monitoring:** Real-time metrics and diagnostics - **Console Integration:** Direct access to service console logs **Developer Experience Enhancement:** Instead of managing multiple terminal windows for different services, developers can view all logs and metrics from a single dashboard interface. ### 7. Community and Open Source **Growth Metrics:** - 60,000+ developers using Aspire - 700+ community PRs (approximately 2 per day) - 70% adoption rate among top .NET customers at Microsoft **Open Source First Approach:** - All development happens in the open - Community contributions actively encouraged - Transparent roadmap and feature development ## Technical Deep Dive ### Architecture Patterns #### App Host Pattern The App Host serves as the central configuration point for the entire application: ```csharp var builder = DistributedApplication.CreateBuilder(args); // Infrastructure dependencies var postgres = builder.AddPostgres("postgres"); var redis = builder.AddRedis("redis"); var storage = builder.AddAzureStorage("storage"); // Application services var api = builder.AddProject<Projects.Api>("api") .WithReference(postgres) .WithReference(redis); var web = builder.AddProject<Projects.Web>("web") .WithReference(api) .WithReference(storage); builder.Build().Run(); ``` #### Service Defaults Standardized configuration applied to all services: - OpenTelemetry integration - Health checks - Resilience patterns (Polly) - Service discovery - Configuration management ### Configuration Management **Traditional Approach Problems:** - Mixed business and infrastructure configuration - Hard-coded API keys and connection strings - Environment-specific configuration files - Manual resource coordination **Aspire Solution:** - **Parameterized Configuration:** External parameters for sensitive data - **Connection String Injection:** Automatic connection string management - **Managed Identity Support:** Seamless authentication token handling - **Environment-Specific Overrides:** Different configurations per deployment target ### Deployment Flexibility #### Multi-Target Support ```csharp // Azure Container Apps builder.AddAzureContainerAppEnvironment("production"); // Azure App Service builder.AddAzureAppServiceEnvironment("staging"); // Docker Compose (Preview) builder.AddDockerComposeEnvironment("development"); // Kubernetes (Community) builder.AddKubernetesEnvironment("cluster"); ``` #### Cross-Environment Communication Aspire automatically handles service-to-service communication across different compute environments: - Network configuration - Service discovery - Load balancing - Security policies ## Best Practices and Recommendations ### 1. Starting New Projects **Recommendation:** Begin with Aspire from day one rather than retrofitting existing applications. **Benefits:** - Immediate productivity gains - Consistent development patterns - Built-in observability and resilience - Simplified deployment pipeline ### 2. Migration Strategy For existing applications, focus on: 1. **Authentication Patterns:** Move from API keys to managed identities 2. **Configuration Management:** Externalize configuration from code 3. **Service Boundaries:** Identify natural service boundaries for containerization 4. **Dependency Management:** Catalog external dependencies (databases, message queues, etc.) ### 3. Multi-Language Integration When incorporating non-.NET components: - Use container-based integration - Maintain consistent configuration patterns - Leverage Aspire's orchestration capabilities - Document service contracts and APIs ### 4. Version Management - Update Aspire regularly (every 6 weeks) - Use `dotnet new update` for template updates - Implement automated dependency updates in CI/CD - Monitor for breaking changes in preview features ## Future Roadmap and Implications ### Near-Term Developments - **Enhanced Multi-Language Support:** Continued improvement of JavaScript, Python, and Go integration - **Deployment Target Expansion:** Additional cloud providers and deployment platforms - **Visual Studio Integration:** Improved template update experience - **CLI Enhancements:** Extended command-line functionality ### Strategic Direction - **Cloud-Agnostic Deployment:** Support for AWS, Google Cloud, and other platforms - **Enterprise Integration:** Advanced CI/CD pipeline integration - **AI/ML Workflow Support:** Enhanced patterns for AI/ML application development - **Performance Optimization:** Continued focus on development and runtime performance ## Challenges and Considerations ### Current Limitations 1. **Preview Features:** Many advanced features still in preview 2. **Learning Curve:** Developers need to understand new patterns and concepts 3. **Enterprise Integration:** Some enterprise scenarios require custom solutions 4. **Multi-Cloud Complexity:** Cross-cloud deployments add complexity ### Mitigation Strategies - **Gradual Adoption:** Start with local development, expand to deployment - **Team Training:** Invest in developer education and training - **Community Engagement:** Participate in open source community - **Feedback Loop:** Actively provide feedback to Microsoft team ## Conclusion .NET Aspire represents a significant evolution in .NET development tooling, addressing the complexity of modern application development through unified orchestration, simplified deployment, and enhanced developer experience. The session demonstrated maturity in AI integration, multi-language support, and deployment flexibility while maintaining the core promise of reducing developer friction. The combination of strong community adoption, active open source development, and Microsoft's internal usage validates Aspire's approach to modern application development. As the platform continues to evolve, it positions itself as an essential tool for teams building cloud-native applications with .NET. The key takeaway is that Aspire is not just a development tool but a comprehensive platform that bridges the gap between local development and production deployment, making it possible for developers to focus on business logic rather than infrastructure complexity. --- ## References - [.NET Aspire Documentation](https://learn.microsoft.com/en-us/dotnet/aspire/) - Official Microsoft documentation for .NET Aspire, providing comprehensive guides, tutorials, and API references. Essential for understanding core concepts, getting started guides, and implementation details discussed in the session. - [Semantic Kernel GitHub Repository](https://github.com/microsoft/semantic-kernel) - Open-source project mentioned by Devis Lucato as the foundation for his AI work. Demonstrates the evolution from multi-language SDK maintenance to web service-based architecture that Aspire enables. - [Azure Container Apps Documentation](https://learn.microsoft.com/en-us/azure/container-apps/) - Primary deployment target for Aspire applications, featured prominently in the session's deployment demonstrations. Understanding Container Apps is crucial for implementing the deployment strategies discussed. - [Azure App Service Documentation](https://learn.microsoft.com/en-us/azure/app-service/) - Alternative deployment target showcased in the multi-environment deployment demo. Represents the flexibility of Aspire's compute environment abstraction. - [OpenTelemetry .NET Documentation](https://learn.microsoft.com/en-us/dotnet/core/diagnostics/observability-with-otel) - Fundamental observability framework integrated into Aspire by default. Critical for understanding the telemetry and monitoring capabilities demonstrated in the session. - [Azure Developer CLI (azd) Documentation](https://learn.microsoft.com/en-us/azure/developer/azure-developer-cli/) - Deployment tool that integrates with Aspire for Azure deployments. Essential for understanding the deployment pipeline and infrastructure-as-code generation shown in the demos. - [Docker Compose Documentation](https://docs.docker.com/compose/) - Alternative orchestration approach mentioned in Devis's presentation. Provides context for understanding why Aspire's approach is superior for complex multi-service applications. - [Microsoft Extensions AI Documentation](https://learn.microsoft.com/en-us/dotnet/ai/) - AI integration framework demonstrated in the session's image processing demo. Shows how Aspire facilitates AI-powered application development. - [Polly Resilience Framework](https://github.com/App-vNext/Polly) - Resilience patterns and retry mechanisms built into Aspire's service defaults. Important for understanding the built-in reliability features mentioned in the session. - [.NET Generic Host Documentation](https://learn.microsoft.com/en-us/dotnet/core/extensions/generic-host) - Foundation for Aspire's app host pattern. Understanding the generic host model is crucial for comprehending how Aspire orchestrates application services. - [Azure Resource Manager (ARM) Templates](https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/) - Infrastructure-as-code output generated by Aspire deployments. Understanding ARM/Bicep is helpful for customizing and troubleshooting deployment outputs. - [Container Registry Documentation](https://learn.microsoft.com/en-us/azure/container-registry/) - Container image management for Aspire applications using containerized services. Important for understanding the container deployment pipeline. - [GitHub Actions for .NET](https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net) - CI/CD integration mentioned as part of Aspire's development workflow. Essential for implementing automated deployment pipelines. - [Visual Studio Code C# Dev Kit](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp) - Development environment showcased in the session, including new launch project selection features. Important for developers using VS Code with Aspire. - [Microsoft Learn - Cloud-Native Application Development](https://learn.microsoft.com/en-us/training/paths/dotnet-microservices/) - Educational content related to cloud-native development patterns that Aspire facilitates. Provides broader context for understanding modern application architecture principles discussed in the session.